{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * final dataset, after revisions\n",
    " * several bug fixes in pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/extended_23_run_14/1/AstroCNNModel_extended_20210131_212427',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/2/AstroCNNModel_extended_20210131_215717',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/3/AstroCNNModel_extended_20210131_222957',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/4/AstroCNNModel_extended_20210131_230255',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/5/AstroCNNModel_extended_20210131_233546',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/6/AstroCNNModel_extended_20210201_000826',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/7/AstroCNNModel_extended_20210201_004107',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/8/AstroCNNModel_extended_20210201_011350',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/9/AstroCNNModel_extended_20210201_014655',\n",
       " '/mnt/tess/astronet/checkpoints/extended_23_run_14/10/AstroCNNModel_extended_20210201_021945']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/extended_23_run_14'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-s33-cam2-ccd14-sample/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-tmp-ext-all.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 2\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 3\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 4\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 5\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 6\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 7\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 8\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 9\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n",
      "Running model 10\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "577 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_E', 'disp_N', 'disp_J', 'disp_S', 'disp_B']\n",
    "\n",
    "col_e = labels.index('disp_E')\n",
    "thresh = config.hparams.prediction_threshold\n",
    "# thresh = 0.95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_E')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9826086956521739\n",
      "Precision: 0.7687074829931972\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_E_p'] > 0)\n",
    "pos = (pl['disp_E'] > 0)\n",
    "\n",
    "pneg = (pl['disp_E_p'] == 0)\n",
    "neg = (pl['disp_E'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37496370\n",
      "37916191\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32704930\n",
      "32875157\n",
      "49771588\n",
      "123982605\n",
      "60174275\n",
      "124180579\n",
      "37910921\n",
      "123799131\n",
      "124227274\n",
      "123902031\n",
      "299584383\n",
      "32703836\n",
      "93123746\n",
      "33419266\n",
      "37387074\n",
      "124277948\n",
      "48543242\n",
      "93416658\n",
      "123666771\n",
      "37998266\n",
      "37116846\n",
      "123571813\n",
      "38025039\n",
      "37502920\n",
      "60117518\n",
      "32641882\n",
      "37156612\n",
      "37765377\n",
      "33471560\n",
      "32946867\n",
      "37391638\n",
      "124274125\n",
      "93171065\n",
      "93058423\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 249951802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E_p</th>\n",
       "      <th>disp_N_p</th>\n",
       "      <th>disp_J_p</th>\n",
       "      <th>disp_S_p</th>\n",
       "      <th>disp_B_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E_p, disp_N_p, disp_J_p, disp_S_p, disp_B_p, maxcount, disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 421845505]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_E']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = float(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.967864072374453, max R: 1.0, max P: 1.0\n",
      "100% recall at: 41%, threshold: 0.0049582767487117985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    if p > 0:\n",
    "        ps.append(p)\n",
    "        rs.append(r)\n",
    "    else:\n",
    "        ps.append(1.0)\n",
    "        rs.append(0.0)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80% precision at: 98%, threshold: 0.31245827674871207\n"
     ]
    }
   ],
   "source": [
    "i = len(rs) - 1\n",
    "while ps[i] <= 0.8:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'80% precision at: {int(rs[i] * 100)}%, threshold: {ths[i]}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
